"""
认证管理模块 - 阶段1：初始化和认证
"""
import json
import time
import os
from typing import Optional, Dict, Any
import requests
from config.config import settings
from utils.logger import app_logger

class AuthManager:
    """认证管理器"""
    
    TOKEN_FILE = "data/auth.json"  # token文件存储路径
    
    def __init__(self):
        self.token: Optional[str] = None
        self.token_expires_at: Optional[int] = None
        self.session = requests.Session()
        self.session.timeout = settings.REQUEST_TIMEOUT
        
        # 禁用SSL证书验证以解决证书验证失败问题
        self.session.verify = False
        
        # 禁用SSL警告
        import urllib3
        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
        
        # 确保数据目录存在
        os.makedirs(os.path.dirname(self.TOKEN_FILE), exist_ok=True)
        
    def get_token(self, force_refresh: bool = False) -> Optional[str]:
        """
        获取访问令牌
        
        Args:
            force_refresh: 是否强制刷新令牌
            
        Returns:
            访问令牌或None
        """
        try:
            # 检查是否需要刷新令牌
            if not force_refresh and self.token and self._is_token_valid():
                app_logger.info("使用现有有效令牌")
                return self.token
            
            app_logger.info("开始获取新的访问令牌")
            
            # 准备认证请求
            auth_data = {
                "clientId": settings.AUTH_CLIENT_ID,
                "clientSecret": settings.AUTH_CLIENT_SECRET
            }
            
            # 发送认证请求
            response = self.session.post(
                url=settings.AUTH_URL,
                json=auth_data,
                headers={"Content-Type": "application/json"}
            )
            
            if response.status_code == 200:
                token_data = response.json()
                app_logger.info(f"认证响应: {token_data}")
                
                # 解析飞书API响应格式
                if token_data.get("code") == "0":  # 飞书API成功响应（注意code是字符串）
                    data = token_data.get("data", {})
                    self.token = data.get("accessToken")
                    
                    # 设置令牌过期时间（expireTime是毫秒时间戳）
                    expire_time_ms = data.get("expireTime")
                    if expire_time_ms:
                        self.token_expires_at = int(expire_time_ms / 1000)  # 转换为秒
                        expires_in = self.token_expires_at - int(time.time())
                    else:
                        # 如果没有过期时间，默认2小时
                        expires_in = 7200
                        self.token_expires_at = int(time.time()) + expires_in
                    
                    # 保存令牌到文件
                    self._save_token_to_file(self.token, self.token_expires_at)
                    
                    # 更新请求头
                    self._update_auth_headers()
                    
                    app_logger.info(f"成功获取访问令牌，有效期：{expires_in}秒")
                    return self.token
                else:
                    app_logger.error(f"认证失败: {token_data.get('msg', '未知错误')}")
                    return None
            else:
                app_logger.error(f"获取令牌失败，状态码：{response.status_code}，响应：{response.text}")
                return None
                
        except Exception as e:
            app_logger.error(f"获取令牌时发生异常：{str(e)}")
            return None
    
    def _is_token_valid(self) -> bool:
        """检查令牌是否有效"""
        if not self.token or not self.token_expires_at:
            return False
        
        # 提前5分钟刷新令牌
        return int(time.time()) < (self.token_expires_at - 300)
    
    def _save_token_to_file(self, token: str, expires_at: int):
        """保存令牌到文件"""
        try:
            token_info = {
                "token": token,
                "expires_at": expires_at,
                "created_at": int(time.time())
            }
            
            with open(self.TOKEN_FILE, 'w', encoding='utf-8') as f:
                json.dump(token_info, f, ensure_ascii=False, indent=2)
            
            app_logger.info(f"令牌已保存到文件: {self.TOKEN_FILE}")
            
        except Exception as e:
            app_logger.error(f"保存令牌到文件失败：{str(e)}")
    
    def _load_token_from_file(self) -> bool:
        """从文件加载令牌"""
        try:
            if not os.path.exists(self.TOKEN_FILE):
                return False
            
            with open(self.TOKEN_FILE, 'r', encoding='utf-8') as f:
                token_info = json.load(f)
            
            self.token = token_info.get("token")
            self.token_expires_at = token_info.get("expires_at")
            
            app_logger.info("从文件加载令牌成功")
            return True
            
        except Exception as e:
            app_logger.error(f"从文件加载令牌失败：{str(e)}")
            return False


    
    def _update_auth_headers(self):
        """更新请求头中的认证信息"""
        if self.token:
            self.session.headers.update({
                "Authorization": self.token
            })
    
    def get_auth_headers(self) -> Dict[str, str]:
        """获取认证请求头"""
        token = self.get_token()
        if token:
            return {"Authorization": token}
        return {}
    
    def initialize(self) -> bool:
        """初始化认证管理器"""
        try:
            app_logger.info("开始初始化认证管理器")
            
            # 从文件加载现有令牌
            self._load_token_from_file()
            
            # 获取或刷新令牌
            token = self.get_token()
            
            if token:
                app_logger.info("认证管理器初始化成功")
                return True
            else:
                app_logger.error("认证管理器初始化失败：无法获取令牌")
                return False
                
        except Exception as e:
            app_logger.error(f"认证管理器初始化异常：{str(e)}")
            return False
    


# 全局认证管理器实例
auth_manager = AuthManager() 